1   /**
2    * Copyright 2014 Netflix, Inc.
3    * 
4    * Licensed under the Apache License, Version 2.0 (the "License");
5    * you may not use this file except in compliance with the License.
6    * You may obtain a copy of the License at
7    * 
8    * http://www.apache.org/licenses/LICENSE-2.0
9    * 
10   * Unless required by applicable law or agreed to in writing, software
11   * distributed under the License is distributed on an "AS IS" BASIS,
12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13   * See the License for the specific language governing permissions and
14   * limitations under the License.
15   */
16  package rx.internal.operators;
17  
18  import static org.mockito.Matchers.any;
19  import static org.mockito.Matchers.anyString;
20  import static org.mockito.Matchers.isA;
21  import static org.mockito.Mockito.inOrder;
22  import static org.mockito.Mockito.mock;
23  import static org.mockito.Mockito.never;
24  import static org.mockito.Mockito.times;
25  import static org.mockito.Mockito.verify;
26  import static org.mockito.MockitoAnnotations.initMocks;
27  
28  import java.util.NoSuchElementException;
29  
30  import org.junit.Before;
31  import org.junit.Test;
32  import org.mockito.InOrder;
33  import org.mockito.Mock;
34  
35  import rx.Observable;
36  import rx.Observer;
37  import rx.functions.Func1;
38  
39  public class OperatorFirstTest {
40  
41      @Mock
42      Observer<String> w;
43  
44      private static final Func1<String, Boolean> IS_D = new Func1<String, Boolean>() {
45          @Override
46          public Boolean call(String value) {
47              return "d".equals(value);
48          }
49      };
50  
51      @Before
52      public void before() {
53          initMocks(this);
54      }
55  
56      @Test
57      public void testFirstOrElseOfNone() {
58          Observable<String> src = Observable.empty();
59          src.firstOrDefault("default").subscribe(w);
60  
61          verify(w, times(1)).onNext(anyString());
62          verify(w, times(1)).onNext("default");
63          verify(w, never()).onError(any(Throwable.class));
64          verify(w, times(1)).onCompleted();
65      }
66  
67      @Test
68      public void testFirstOrElseOfSome() {
69          Observable<String> src = Observable.just("a", "b", "c");
70          src.firstOrDefault("default").subscribe(w);
71  
72          verify(w, times(1)).onNext(anyString());
73          verify(w, times(1)).onNext("a");
74          verify(w, never()).onError(any(Throwable.class));
75          verify(w, times(1)).onCompleted();
76      }
77  
78      @Test
79      public void testFirstOrElseWithPredicateOfNoneMatchingThePredicate() {
80          Observable<String> src = Observable.just("a", "b", "c");
81          src.firstOrDefault("default", IS_D).subscribe(w);
82  
83          verify(w, times(1)).onNext(anyString());
84          verify(w, times(1)).onNext("default");
85          verify(w, never()).onError(any(Throwable.class));
86          verify(w, times(1)).onCompleted();
87      }
88  
89      @Test
90      public void testFirstOrElseWithPredicateOfSome() {
91          Observable<String> src = Observable.just("a", "b", "c", "d", "e", "f");
92          src.firstOrDefault("default", IS_D).subscribe(w);
93  
94          verify(w, times(1)).onNext(anyString());
95          verify(w, times(1)).onNext("d");
96          verify(w, never()).onError(any(Throwable.class));
97          verify(w, times(1)).onCompleted();
98      }
99  
100     @Test
101     public void testFirst() {
102         Observable<Integer> observable = Observable.just(1, 2, 3).first();
103 
104         @SuppressWarnings("unchecked")
105         Observer<Integer> observer = mock(Observer.class);
106         observable.subscribe(observer);
107 
108         InOrder inOrder = inOrder(observer);
109         inOrder.verify(observer, times(1)).onNext(1);
110         inOrder.verify(observer, times(1)).onCompleted();
111         inOrder.verifyNoMoreInteractions();
112     }
113 
114     @Test
115     public void testFirstWithOneElement() {
116         Observable<Integer> observable = Observable.just(1).first();
117 
118         @SuppressWarnings("unchecked")
119         Observer<Integer> observer = mock(Observer.class);
120         observable.subscribe(observer);
121 
122         InOrder inOrder = inOrder(observer);
123         inOrder.verify(observer, times(1)).onNext(1);
124         inOrder.verify(observer, times(1)).onCompleted();
125         inOrder.verifyNoMoreInteractions();
126     }
127 
128     @Test
129     public void testFirstWithEmpty() {
130         Observable<Integer> observable = Observable.<Integer> empty().first();
131 
132         @SuppressWarnings("unchecked")
133         Observer<Integer> observer = mock(Observer.class);
134         observable.subscribe(observer);
135 
136         InOrder inOrder = inOrder(observer);
137         inOrder.verify(observer, times(1)).onError(
138                 isA(NoSuchElementException.class));
139         inOrder.verifyNoMoreInteractions();
140     }
141 
142     @Test
143     public void testFirstWithPredicate() {
144         Observable<Integer> observable = Observable.just(1, 2, 3, 4, 5, 6)
145                 .first(new Func1<Integer, Boolean>() {
146 
147                     @Override
148                     public Boolean call(Integer t1) {
149                         return t1 % 2 == 0;
150                     }
151                 });
152 
153         @SuppressWarnings("unchecked")
154         Observer<Integer> observer = mock(Observer.class);
155         observable.subscribe(observer);
156 
157         InOrder inOrder = inOrder(observer);
158         inOrder.verify(observer, times(1)).onNext(2);
159         inOrder.verify(observer, times(1)).onCompleted();
160         inOrder.verifyNoMoreInteractions();
161     }
162 
163     @Test
164     public void testFirstWithPredicateAndOneElement() {
165         Observable<Integer> observable = Observable.just(1, 2).first(
166                 new Func1<Integer, Boolean>() {
167 
168                     @Override
169                     public Boolean call(Integer t1) {
170                         return t1 % 2 == 0;
171                     }
172                 });
173 
174         @SuppressWarnings("unchecked")
175         Observer<Integer> observer = mock(Observer.class);
176         observable.subscribe(observer);
177 
178         InOrder inOrder = inOrder(observer);
179         inOrder.verify(observer, times(1)).onNext(2);
180         inOrder.verify(observer, times(1)).onCompleted();
181         inOrder.verifyNoMoreInteractions();
182     }
183 
184     @Test
185     public void testFirstWithPredicateAndEmpty() {
186         Observable<Integer> observable = Observable.just(1).first(
187                 new Func1<Integer, Boolean>() {
188 
189                     @Override
190                     public Boolean call(Integer t1) {
191                         return t1 % 2 == 0;
192                     }
193                 });
194         @SuppressWarnings("unchecked")
195         Observer<Integer> observer = mock(Observer.class);
196         observable.subscribe(observer);
197 
198         InOrder inOrder = inOrder(observer);
199         inOrder.verify(observer, times(1)).onError(
200                 isA(NoSuchElementException.class));
201         inOrder.verifyNoMoreInteractions();
202     }
203 
204     @Test
205     public void testFirstOrDefault() {
206         Observable<Integer> observable = Observable.just(1, 2, 3)
207                 .firstOrDefault(4);
208 
209         @SuppressWarnings("unchecked")
210         Observer<Integer> observer = mock(Observer.class);
211         observable.subscribe(observer);
212 
213         InOrder inOrder = inOrder(observer);
214         inOrder.verify(observer, times(1)).onNext(1);
215         inOrder.verify(observer, times(1)).onCompleted();
216         inOrder.verifyNoMoreInteractions();
217     }
218 
219     @Test
220     public void testFirstOrDefaultWithOneElement() {
221         Observable<Integer> observable = Observable.just(1).firstOrDefault(2);
222 
223         @SuppressWarnings("unchecked")
224         Observer<Integer> observer = mock(Observer.class);
225         observable.subscribe(observer);
226 
227         InOrder inOrder = inOrder(observer);
228         inOrder.verify(observer, times(1)).onNext(1);
229         inOrder.verify(observer, times(1)).onCompleted();
230         inOrder.verifyNoMoreInteractions();
231     }
232 
233     @Test
234     public void testFirstOrDefaultWithEmpty() {
235         Observable<Integer> observable = Observable.<Integer> empty()
236                 .firstOrDefault(1);
237 
238         @SuppressWarnings("unchecked")
239         Observer<Integer> observer = mock(Observer.class);
240         observable.subscribe(observer);
241 
242         InOrder inOrder = inOrder(observer);
243         inOrder.verify(observer, times(1)).onNext(1);
244         inOrder.verify(observer, times(1)).onCompleted();
245         inOrder.verifyNoMoreInteractions();
246     }
247 
248     @Test
249     public void testFirstOrDefaultWithPredicate() {
250         Observable<Integer> observable = Observable.just(1, 2, 3, 4, 5, 6)
251                 .firstOrDefault(8, new Func1<Integer, Boolean>() {
252 
253                     @Override
254                     public Boolean call(Integer t1) {
255                         return t1 % 2 == 0;
256                     }
257                 });
258 
259         @SuppressWarnings("unchecked")
260         Observer<Integer> observer = mock(Observer.class);
261         observable.subscribe(observer);
262 
263         InOrder inOrder = inOrder(observer);
264         inOrder.verify(observer, times(1)).onNext(2);
265         inOrder.verify(observer, times(1)).onCompleted();
266         inOrder.verifyNoMoreInteractions();
267     }
268 
269     @Test
270     public void testFirstOrDefaultWithPredicateAndOneElement() {
271         Observable<Integer> observable = Observable.just(1, 2).firstOrDefault(
272                 4, new Func1<Integer, Boolean>() {
273 
274                     @Override
275                     public Boolean call(Integer t1) {
276                         return t1 % 2 == 0;
277                     }
278                 });
279 
280         @SuppressWarnings("unchecked")
281         Observer<Integer> observer = mock(Observer.class);
282         observable.subscribe(observer);
283 
284         InOrder inOrder = inOrder(observer);
285         inOrder.verify(observer, times(1)).onNext(2);
286         inOrder.verify(observer, times(1)).onCompleted();
287         inOrder.verifyNoMoreInteractions();
288     }
289 
290     @Test
291     public void testFirstOrDefaultWithPredicateAndEmpty() {
292         Observable<Integer> observable = Observable.just(1).firstOrDefault(2,
293                 new Func1<Integer, Boolean>() {
294 
295                     @Override
296                     public Boolean call(Integer t1) {
297                         return t1 % 2 == 0;
298                     }
299                 });
300 
301         @SuppressWarnings("unchecked")
302         Observer<Integer> observer = mock(Observer.class);
303         observable.subscribe(observer);
304 
305         InOrder inOrder = inOrder(observer);
306         inOrder.verify(observer, times(1)).onNext(2);
307         inOrder.verify(observer, times(1)).onCompleted();
308         inOrder.verifyNoMoreInteractions();
309     }
310 }